package mobile

import (
	"fmt"
	"log"
	"net"
	"os"
	"time"

	"github.com/babytap/server/internal/server"
	"github.com/babytap/server/pkg/discovery"
)

// HTTPSServer 移动端 HTTPS 服务器
type HTTPSServer struct {
	server *server.HTTPSServer
	port   int
	// 文件访问服务引用（通过 JNI 调用）
	fileAccessService interface{}
	// 启动时间记录
	startTime time.Time
	// 启动状态
	isStarting bool
	// UDP 发现服务
	udpDiscovery *discovery.UDPDiscovery
}

// NewHTTPSServerWithDynamicPort 创建新的 HTTPS 服务器（动态端口）
func NewHTTPSServerWithDynamicPort(dataDir string) (*HTTPSServer, error) {
	startTime := time.Now()
	log.Printf("🚀 开始创建动态端口服务器...")

	// 查找可用端口
	port, err := FindAvailablePortInRange()
	if err != nil {
		return nil, fmt.Errorf("查找可用端口失败: %w", err)
	}

	log.Printf("🔍 找到可用端口: %d (耗时: %v)", port, time.Since(startTime))

	// 创建服务器
	return NewHTTPSServer(port, dataDir)
}

// NewHTTPSServer 创建新的 HTTPS 服务器
func NewHTTPSServer(port int, dataDir string) (*HTTPSServer, error) {
	startTime := time.Now()
	log.Printf("🚀 开始创建 HTTPS 服务器，端口: %d...", port)

	// 确保数据目录存在
	if err := os.MkdirAll(dataDir, 0755); err != nil {
		return nil, fmt.Errorf("创建数据目录失败: %w", err)
	}

	// 获取本机 IP 地址
	localIPs := getLocalIPAddresses()
	log.Printf("🌐 检测到本机 IP 地址: %v", localIPs)

	// 获取设备名称（默认为手机型号）
	deviceName := getDeviceName()

	// 创建 UDP 发现服务
	deviceInfo := discovery.DeviceInfo{
		ID:         fmt.Sprintf("BabyTapMobile-%d", time.Now().Unix()),
		Name:       deviceName,
		Addresses:  localIPs,
		Port:       port,
		InstanceID: time.Now().Unix(),
	}

	udpDiscovery := discovery.NewUDPDiscovery(deviceInfo, func(foundDevice discovery.DeviceInfo) {
		log.Printf("🎯 UDP 发现新设备: %s (%s:%d)", foundDevice.Name, foundDevice.Addresses, foundDevice.Port)
	})

	// 创建服务器（带UDP发现服务）
	srv, err := server.NewHTTPSServerWithUDPDiscovery(port, dataDir, udpDiscovery)
	if err != nil {
		return nil, fmt.Errorf("创建 HTTPS 服务器失败: %w", err)
	}

	log.Printf("✅ 服务器创建完成 (耗时: %v)", time.Since(startTime))

	return &HTTPSServer{
		server:       srv,
		port:         port,
		startTime:    startTime,
		udpDiscovery: udpDiscovery,
	}, nil
}

// getDeviceName 获取设备名称（默认值）
func getDeviceName() string {
	// 由于Go无法直接获取Android设备型号，这里返回一个默认值
	// 实际的设备名称将通过Android端传入或通过API设置
	return "BabyTap手机"
}

// SetDeviceName 设置设备名称（供Android端调用）
func (h *HTTPSServer) SetDeviceName(name string) {
	if h.udpDiscovery != nil {
		h.udpDiscovery.SetDeviceName(name)
		log.Printf("📝 设备名称已设置为: %s", name)
	}
}

// Start 启动服务器
func (h *HTTPSServer) Start() error {
	if h.isStarting {
		return fmt.Errorf("服务器正在启动中")
	}

	h.isStarting = true

	log.Printf("🚀 启动移动端 HTTPS 服务器，端口: %d", h.port)

	// 启动 UDP 发现服务（在 HTTPS 服务器之前启动）
	if h.udpDiscovery != nil {
		log.Printf("🔍 启动 UDP 发现服务...")

		// 添加详细的 UDP 发现服务信息
		log.Printf("📋 UDP 发现服务配置:")
		log.Printf("   - 设备 ID: %s", h.udpDiscovery.GetDeviceInfo().ID)
		log.Printf("   - 设备名称: %s", h.udpDiscovery.GetDeviceInfo().Name)
		log.Printf("   - 设备端口: %d", h.udpDiscovery.GetDeviceInfo().Port)
		log.Printf("   - 设备地址: %v", h.udpDiscovery.GetDeviceInfo().Addresses)
		log.Printf("   - 实例 ID: %d", h.udpDiscovery.GetDeviceInfo().InstanceID)

		err := h.udpDiscovery.Start()
		if err != nil {
			log.Printf("❌ UDP 发现服务启动失败: %v", err)
			log.Printf("🔧 错误详情: %+v", err)
			// UDP 发现失败不影响主服务器运行
		} else {
			log.Printf("✅ UDP 发现服务启动成功")
			log.Printf("📡 UDP 发现服务正在监听端口 8554")
		}
	} else {
		log.Printf("⚠️ UDP 发现服务未初始化")
	}

	// 启动 HTTPS 服务器（同步启动，但 UDP 发现服务已经启动）
	log.Printf("🔄 启动 HTTPS 服务器...")
	err := h.server.Start()
	if err != nil {
		h.isStarting = false
		return fmt.Errorf("HTTPS 服务器启动失败: %w", err)
	}

	h.isStarting = false
	log.Printf("✅ 服务器启动完成 (总耗时: %v)", time.Since(h.startTime))
	return nil
}

// Stop 停止服务器
func (h *HTTPSServer) Stop() error {
	log.Printf("🛑 停止移动端 HTTPS 服务器")

	// 停止 UDP 发现服务
	if h.udpDiscovery != nil {
		log.Printf("🛑 停止 UDP 发现服务...")
		h.udpDiscovery.Stop()
		log.Printf("✅ UDP 发现服务已停止")
	}

	return h.server.Stop()
}

// GetPort 获取服务器端口
func (h *HTTPSServer) GetPort() int {
	return h.port
}

// GetDataDir 获取数据目录
func (h *HTTPSServer) GetDataDir() string {
	return h.server.DataDir
}

// IsRunning 检查服务器是否运行
func (h *HTTPSServer) IsRunning() bool {
	return h.server != nil && !h.isStarting
}

// GetStartupTime 获取启动耗时
func (h *HTTPSServer) GetStartupTime() time.Duration {
	return time.Since(h.startTime)
}

// GetPortStatus 获取端口状态
func (h *HTTPSServer) GetPortStatus(port int) string {
	return GetPortStatus(port)
}

// CheckPortAvailability 检查指定端口是否可用
func (h *HTTPSServer) CheckPortAvailability(port int) bool {
	return IsPortAvailable(port)
}

// SetFileAccessService 设置文件访问服务
func (h *HTTPSServer) SetFileAccessService(service interface{}) {
	h.fileAccessService = service
}

// GetFileAccessService 获取文件访问服务
func (h *HTTPSServer) GetFileAccessService() interface{} {
	return h.fileAccessService
}

// getLocalIPAddresses 获取本机所有局域网 IP 地址
func getLocalIPAddresses() []string {
	var ips []string

	interfaces, err := net.Interfaces()
	if err != nil {
		log.Printf("获取网络接口失败: %v", err)
		// 返回默认IP作为后备
		return []string{"127.0.0.1"}
	}

	for _, iface := range interfaces {
		// 跳过回环接口和未启用的接口
		if iface.Flags&net.FlagLoopback != 0 || iface.Flags&net.FlagUp == 0 {
			continue
		}

		addrs, err := iface.Addrs()
		if err != nil {
			log.Printf("获取接口 %s 地址失败: %v", iface.Name, err)
			continue
		}

		for _, addr := range addrs {
			if ipnet, ok := addr.(*net.IPNet); ok {
				// 只处理 IPv4 地址
				if ip4 := ipnet.IP.To4(); ip4 != nil {
					// 检查是否是局域网 IP
					if ip4[0] == 10 ||
						(ip4[0] == 172 && ip4[1] >= 16 && ip4[1] <= 31) ||
						(ip4[0] == 192 && ip4[1] == 168) {
						ips = append(ips, ip4.String())
						log.Printf("找到局域网IP: %s (接口: %s)", ip4.String(), iface.Name)
					}
				}
			}
		}
	}

	// 如果没有找到局域网IP，返回默认IP
	if len(ips) == 0 {
		log.Printf("未找到局域网IP，使用默认IP")
		ips = append(ips, "127.0.0.1")
	}

	return ips
}
